<nodeTypes>

	<nodeType name="generalNode">
		has state. var size.		
	</nodeType>
	
	<nodeType name="generalDFunc">
		stateless. constant size input, constant size max temp use, constant size output.
	</nodeType>
	
	<nodeType name="DArray">
		has state. constant size sequence of doubles.
	</nodeType>
	
	TODO: how to connect a sequence of generalDFunc and call them in sequence?
	
	TODO?: nodeType for reordering or moving a sequence of D, and having some index used and some not?
	
	<removedFromNetDotJava>
		/** function that swaps 2 childs in a node by their index in that node */
		public fNodeI2r nodeChildSwap();
	</removedFromNetDotJava>

	<removedFromNodeDotJava>		
		//** executes this node, which uses its DFuncs, its child Nodes, and its doubles *
		//public void nodeExec();
	
		//TODO: define, per node, which things are iterated over:
		//examples: this node 1, childCount, 2^childCount, 3*5^childCount, child node 1.
		//Something like an iterator will give 1 int for each of these per iteration.
		
		//Example double size calculation and therefore mapping to ints, where C=nodes().size():
		//5+3*C+2^C+C*C*3^C
		//sum of: (C^X)*(Y^C), where 0 <= X and 1 <= Y  
		
		//TODO: how to iterate
		
		/*
		//TODO: there is only 1 node class. only the dlambdas, network shape, and doubles vary.
		
		//public java.util.List<Node> childNodes();
		
		//Node should have const quantity of lists of Node and const quantity of lists of double,
		//all stored efficiently in arrays probably.
		
		/** adds child at end. Probably changes quantity of double numbers.
		For example, a bayes node would have 2x as many double numbers for each child added.
		Those numbers probably need to be changed from their initial value.
		This may cause range in Node array to be copied to a location where more space is empty.
		*
		public void pushNode(Node n);
		
		/** Removes the last child. Probably changes quantity of double numbers. *
		public void popNode();
		
		/** swaps the child Node with the last (or first?) child Node.
		Multiple calls of this can create any child order.
		*
		public void moveNode(int childNodeIndex);
		
		public void swapNode(int childNodeIndexA, int childNodeIndexB);
		
		public int minNodes();
		
		public int maxNodes();
		
		public int countNodes();
		
		//Should childs be stored in a shared Node array, and have startIndex and size ints?
		//If shared Node array, how to add Nodes? Need array range allocator.
		
		/** executes my DLambda functions on my doubles and child Nodes *
		public void run();
		
		//TODO: multiple lists of child nodes for each node are allowed.
		
		/** copies child nodes into the array *
		public void childNodes(int startIndex, Node nodes[]);
		
		public int countNodes();
		
		/** copies my doubles into the array. For example, a bayes node has 2^(childCount+1) numbers *
		public void doubles(int startIndex, double d[]);
		
		public int countDoubles();
		
		/** copies my DLambda functions into the array *
		public void lambdas(int startIndex, DLambda dlam[]);
		
		public int countDLambdas();
		*/
	</removedFromNodeDotJava>

</nodeTypes>